/**
 * 数据验证和格式化工具类
 */

/**
 * 验证身份证号码
 * @param {string} idCard 身份证号码
 * @returns {object} 验证结果
 */
export function validateIdCard(idCard) {
  if (!idCard) {
    return { valid: false, message: '身份证号码不能为空' }
  }
  
  const reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
  if (!reg.test(idCard)) {
    return { valid: false, message: '身份证号码格式不正确' }
  }
  
  // 15位身份证号码检验
  if (idCard.length === 15) {
    return { valid: true, message: '身份证号码有效', type: '15位' }
  }
  
  // 18位身份证号码检验
  if (idCard.length === 18) {
    const factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
    const parity = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2]
    let sum = 0
    
    for (let i = 0; i < 17; i++) {
      sum += idCard[i] * factor[i]
    }
    
    const last = parity[sum % 11]
    const lastChar = idCard[17].toUpperCase()
    
    if (last == lastChar) {
      return { valid: true, message: '身份证号码有效', type: '18位' }
    } else {
      return { valid: false, message: '身份证号码校验位不正确' }
    }
  }
  
  return { valid: false, message: '身份证号码长度不正确' }
}

/**
 * 验证手机号码
 * @param {string} phone 手机号码
 * @returns {object} 验证结果
 */
export function validatePhone(phone) {
  if (!phone) {
    return { valid: false, message: '手机号码不能为空' }
  }
  
  const reg = /^1[3-9]\d{9}$/
  if (!reg.test(phone)) {
    return { valid: false, message: '手机号码格式不正确' }
  }
  
  return { valid: true, message: '手机号码有效' }
}

/**
 * 验证邮箱地址
 * @param {string} email 邮箱地址
 * @returns {object} 验证结果
 */
export function validateEmail(email) {
  if (!email) {
    return { valid: false, message: '邮箱地址不能为空' }
  }
  
  const reg = /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/
  if (!reg.test(email)) {
    return { valid: false, message: '邮箱地址格式不正确' }
  }
  
  return { valid: true, message: '邮箱地址有效' }
}

/**
 * 验证信用分范围
 * @param {number} score 信用分
 * @returns {object} 验证结果
 */
export function validateCreditScore(score) {
  if (score === null || score === undefined || isNaN(score)) {
    return { valid: false, message: '信用分不能为空' }
  }
  
  if (score < 350 || score > 850) {
    return { valid: false, message: '信用分应在350-850之间' }
  }
  
  return { valid: true, message: '信用分有效' }
}

/**
 * 验证金额格式
 * @param {string|number} amount 金额
 * @returns {object} 验证结果
 */
export function validateAmount(amount) {
  if (!amount && amount !== 0) {
    return { valid: false, message: '金额不能为空' }
  }
  
  const num = parseFloat(amount)
  if (isNaN(num)) {
    return { valid: false, message: '金额格式不正确' }
  }
  
  if (num < 0) {
    return { valid: false, message: '金额不能为负数' }
  }
  
  if (!/^\d+(\.\d{1,2})?$/.test(amount.toString())) {
    return { valid: false, message: '金额最多保留两位小数' }
  }
  
  return { valid: true, message: '金额有效', value: num }
}

/**
 * 格式化金额显示
 * @param {number} amount 金额
 * @param {string} currency 货币符号
 * @returns {string} 格式化后的金额
 */
export function formatAmount(amount, currency = '¥') {
  if (!amount && amount !== 0) return '--'
  
  const num = parseFloat(amount)
  if (isNaN(num)) return '--'
  
  return currency + num.toLocaleString('zh-CN', {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2
  })
}

/**
 * 格式化日期时间
 * @param {string|Date} date 日期
 * @param {string} format 格式
 * @returns {string} 格式化后的日期
 */
export function formatDateTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!date) return '--'
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return '--'
  
  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hours = String(d.getHours()).padStart(2, '0')
  const minutes = String(d.getMinutes()).padStart(2, '0')
  const seconds = String(d.getSeconds()).padStart(2, '0')
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
}

/**
 * 格式化相对时间
 * @param {string|Date} date 日期
 * @returns {string} 相对时间
 */
export function formatRelativeTime(date) {
  if (!date) return '--'
  
  const d = new Date(date)
  if (isNaN(d.getTime())) return '--'
  
  const now = new Date()
  const diff = now.getTime() - d.getTime()
  const seconds = Math.floor(diff / 1000)
  const minutes = Math.floor(seconds / 60)
  const hours = Math.floor(minutes / 60)
  const days = Math.floor(hours / 24)
  
  if (seconds < 60) return '刚刚'
  if (minutes < 60) return `${minutes}分钟前`
  if (hours < 24) return `${hours}小时前`
  if (days < 7) return `${days}天前`
  
  return formatDateTime(date, 'YYYY-MM-DD')
}

/**
 * 脱敏手机号码
 * @param {string} phone 手机号码
 * @returns {string} 脱敏后的手机号码
 */
export function maskPhone(phone) {
  if (!phone || phone.length !== 11) return phone
  return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
}

/**
 * 脱敏身份证号码
 * @param {string} idCard 身份证号码
 * @returns {string} 脱敏后的身份证号码
 */
export function maskIdCard(idCard) {
  if (!idCard) return idCard
  
  if (idCard.length === 15) {
    return idCard.replace(/(\d{6})\d{6}(\d{3})/, '$1******$2')
  } else if (idCard.length === 18) {
    return idCard.replace(/(\d{6})\d{8}(\d{4})/, '$1********$2')
  }
  
  return idCard
}

/**
 * 脱敏姓名
 * @param {string} name 姓名
 * @returns {string} 脱敏后的姓名
 */
export function maskName(name) {
  if (!name) return name
  
  if (name.length === 2) {
    return name.charAt(0) + '*'
  } else if (name.length > 2) {
    return name.charAt(0) + '*'.repeat(name.length - 2) + name.charAt(name.length - 1)
  }
  
  return name
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @returns {string} 格式化后的文件大小
 */
export function formatFileSize(bytes) {
  if (!bytes || bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 生成随机字符串
 * @param {number} length 长度
 * @returns {string} 随机字符串
 */
export function generateRandomString(length = 8) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  let result = ''
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length))
  }
  return result
}

/**
 * 深度克隆对象
 * @param {any} obj 要克隆的对象
 * @returns {any} 克隆后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj
  if (obj instanceof Date) return new Date(obj.getTime())
  if (obj instanceof Array) return obj.map(item => deepClone(item))
  if (typeof obj === 'object') {
    const clonedObj = {}
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key])
      }
    }
    return clonedObj
  }
}

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {number} wait 等待时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {number} limit 限制时间
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}

/**
 * 检查对象是否为空
 * @param {object} obj 要检查的对象
 * @returns {boolean} 是否为空
 */
export function isEmpty(obj) {
  if (obj === null || obj === undefined) return true
  if (typeof obj === 'string' || Array.isArray(obj)) return obj.length === 0
  if (typeof obj === 'object') return Object.keys(obj).length === 0
  return false
}

/**
 * 数组去重
 * @param {Array} arr 要去重的数组
 * @param {string} key 对象数组去重的键
 * @returns {Array} 去重后的数组
 */
export function uniqueArray(arr, key) {
  if (!Array.isArray(arr)) return []
  
  if (key) {
    const seen = new Set()
    return arr.filter(item => {
      const val = item[key]
      if (seen.has(val)) {
        return false
      } else {
        seen.add(val)
        return true
      }
    })
  } else {
    return [...new Set(arr)]
  }
} 